home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 04 - 1988 / 04.02 Feb 88 / Rotate Source Code / rotString ƒ / rotate.a next >
Encoding:
Text File  |  1987-12-30  |  11.9 KB  |  329 lines  |  [TEXT/MPS ]
  1.     INCLUDE    'SysEqu.a'    ;the usual system equates & macros    
  2.     INCLUDE    'Traps.a'
  3.     INCLUDE    'QuickEqu.a'
  4.     
  5. newPtrClear FUNC EXPORT
  6.     
  7.     IMPORT    SAVERETA1
  8.     
  9.     MOVE.L    (SP)+,A1
  10.     MOVE.L    (SP)+,D0
  11.     _NewPtr    clear
  12.     MOVE.L    A0,(SP)
  13.     JMP    SAVERETA1
  14.     
  15.     ENDF
  16.  
  17.  
  18. Rotate PROC EXPORT
  19. ;------------------------------------------------------------------------
  20. ;    
  21. ; PROCEDURE    Rotate (sourceMap, destMap : bitMap );
  22. ;    
  23. ; given a source and destination bitmap rotate it CCW 90°…
  24. ; bitmap can be of any size, we will align on a word boundaries (v & h)
  25. ;
  26. ;-------------------------------------------------------------------------------
  27. ;    a0 = result of _newPtr call            |    d0 = size of bitMap to allocate
  28. ;    a1 = ptr to src bitMap                |    d1 = width/2  (source)
  29. ;    a2 = ptr to dest bitMap                |    d2 = height/2 (source)
  30. ;    a3 = dest bits                        |    d3 = left | top
  31. ;    a4 = copy of dest bits                |    d4 = ctrPt.h
  32. ;    a5 = not used                        |    d5 = ctrPt.v
  33. ;    a6 = not used                        |    d6 = right | bottom
  34. ;    a7 = not used                        |    d7 = rowBytes of dest bitMap
  35. ;-------------------------------------------------------------------------------
  36. ; ***********************************************************************
  37. ; *                                                                        *
  38. ; *        Initialize destination bitMap (destMap), etc…                    *
  39. ; *                                                                        *
  40. ; ***********************************************************************
  41. ; parameter offsets
  42. ;
  43. DestMap        EQU    4+4                ; offset to dest bitmap ^
  44. SourceMap    EQU DestMap + 4        ; offset to source bitmap ^
  45. ;
  46. ; create local stack frame, and save some registers
  47. ; make room for dest rect to be passed back
  48. ;
  49.     link    a6,#0                ; set up a stack frame (no bytes)
  50.     movem.l    d3-d7/a2-a5,-(sp)    ; save registers pascal may need
  51.  
  52.     move.l    SourceMap(a6),a1    ; point to the source BitMap
  53.     move.l    DestMap(a6),a2        ; point to the dest BitMap
  54. ;
  55. ; compute height of source BitMap rounded up to nearest word
  56. ;                                
  57.     move.w    bounds+bottom(a1),d7; get bottom and put in d7
  58.     sub.w    bounds+top(a1),d7    ; bottom - top = height, put in d7
  59.     move.w    d7,d0                ; save a copy of height for later
  60.                                 ; rnd = (height+15)/16, follows:
  61.     addi.w    #15,d7                ; add 15 to the height, put in d7
  62.     lsr        #4,d7                ; divide by 16
  63.     lsl        #1,d7                ; multiply by 2 = rowBytes of dest bitMap
  64. ;
  65. ; d7 now contains rowBytes of dest bitMap
  66. ;
  67. ; now compute the destRect for dest bitMap
  68. ;
  69.                                 ; compute center point of Source rect
  70.                                 ; note the center points are not necess. the
  71.                                 ; same in the vert dir. relative to srcMap
  72.                                 ; because of rounding that follows (i.e. height
  73.                                 ; of srcMap is dir. prop. to RowBytes of destMap)
  74.     lsr        #1,d0                ; divide height by 2
  75.     move.w    d0,d2                ; make a copy of height/2 for later
  76.     move.w    bounds+top(a1),d5    ; get 'top' of source rect
  77.     add.w    d0,d5                ; d5 now contains vert component of ctr pt
  78.                                 ; compute the width of src rect & put in d4
  79.     move.w    bounds+right(a1),d3    ; get right and put in d3
  80.     sub.w    bounds+left(a1),d3    ; right - left = width, put in d3
  81.     lsr        #1,d3                ; divide width by 2
  82.     move.w    d3,d1                ; make a copy of width/2 for later
  83.     move.w    bounds+right(a1),d4    ; get right of source rect
  84.     sub.w    d3,d4                ; d4 now contains horiz component of ctr pt
  85. ;
  86. ; now get center point and compute bounds for dest bitMap
  87. ; height and width are reversed now for the 2 bitMaps
  88. ;
  89. ; left    :=ctrPt.h - height/2
  90. ; top    :=ctrPt.v - width/2
  91. ; right    :=ctrPt.h + height/2
  92. ; bottom:=ctrPt.v + width/2
  93. ; SetRect(rect, left, top, right, bottom) put data in direct to
  94. ; avoid the overhead of a trap call
  95. ;
  96.                                 ; compute 'top'
  97.     move.w    d5,d3                ; get a copy of ctrPt.v and put in d3
  98.     sub.w    d1,d3                ; ctrPt.v - width/2 = 'top' in d3
  99.     swap    d3                    ; move 'top' to hiword
  100.                                 ; compute 'left'
  101.     move.w    d4,d3                ; get a copy of ctrPt.h and put in loword d3
  102.     sub.w    d2,d3                ; ctrPt.h - height/2 = 'left' in loword d3
  103. ;
  104. ; we now have 'top' in hiword & 'left' in loword d3
  105. ;
  106.                                 ; compute 'bottom'
  107.     move.w    d5,d6                ; get a copy of ctrPt.v in of d3
  108.     add.w    d1,d6                ; ctrPt.v + width/2 = 'bottom' in d3
  109.     swap    d6                    ; move 'bottom' to hiword    
  110.                                 ; compute 'right'
  111.     move.w    d4,d6                ; get a copy of ctrPt.h and put in loword d6
  112.     add.w    d2,d6                ; ctrPt.h + height/2 = 'right' in loword d6
  113. ;
  114. ; we now have 'bottom' in hiword & 'right' in loword d6
  115. ;
  116. ; assign data to dest bitMap structure directly
  117. ;
  118.     move.w    d7,rowBytes(a2)        ; put in rowBytes direct for dest bitMap
  119.     move.l    d3,bounds+topLeft(a2)    ; put the coord pair in direct
  120.     move.l    d6,bounds+botRight(a2)    ; put the coord pair in direct
  121.     move.w    d7,d0                ; put rowbytes in d0
  122.     mulu    rowBytes(a1),d0        ; multiply rowBytes src*dest = d0
  123.     lsl        #3,d0                ; multiply d0 by 8 for size of dest bitMap
  124.     _NewPtr    clear                ; allocate size of dest bitMap (a2 pts to it) 
  125.     move.l    a0,baseaddr(a2)        ; move contents of a0 to baseAddr field
  126.                                 ; of dest bitMap structure
  127.                                 
  128. ;-------------------------------------------------------------------------------
  129. ;    a0 = baseAddr for our locals        |    d0 = rowbytes of srcMap
  130. ;    a1 = points to bits of src bitMap    |    d1 = width/2     (source)
  131. ;    a2 = ptr to dest bitMap                |    d2 = height/2      (source)
  132. ;    a3 = dest bits                        |    d3 = current word srcMap
  133. ;    a4 =                                 |    d4 = copy of width of srcMap
  134. ;    a5 = not used                        |    d5 = current destMap word
  135. ;    a6 = not used                        |    d6 = insideLoop count (current bit)
  136. ;    a7 = not used                        |    d7 = rowBytes of dest bitMap
  137. ;-------------------------------------------------------------------------------
  138. ; ***********************************************************************
  139. ; *                                                                        *
  140. ; *        Start actual rotation of bitMaps                                *
  141. ; *                                                                        *
  142. ; ***********************************************************************
  143. ; Assumptions:
  144. ; height of destination bitMap = rowBytes of srcMap
  145. ;
  146. ; 
  147. ; Get the baseAddr for our locals into a0 - this will make our program much
  148. ; more readable as we will let the assembler do all the addr location calcs
  149. ; for us. The addresses will be a fixed number while the programs is
  150. ; (locked down) and running, therefore, there is no runtime penalty for
  151. ; doing this addr calculation
  152. ;
  153.  
  154.     lea    localVars,a0
  155. ;
  156. ; initialize d0 to contain the pointer to the srcMap
  157. ;
  158.     move.w    rowbytes(a1),d0        ; get rowbytes of srcMap
  159.     
  160. ;
  161. ; get regs pointing to bits
  162. ;
  163.     move.l    (a1),a1                ; a1 pts to BITS of src bitMap    
  164.     move.l    (a2),a3                ; a3 pts to BITS of dest bitMap
  165.  
  166. computeInitLowerLeft
  167. ; 
  168. ; compute the lower left corner of the destMap - this maps to the upper left
  169. ; corner of the srcMap and will be used as base from which to offset into
  170. ; the dest map when we need to set a bit
  171. ;
  172.     clr.l    d1                    ; clear d1 
  173.     move.w    d0,d1                ; load rowBytes of srcMap
  174.                                 ; (rowBytes of srcMap = ht of destMap)
  175.     lsl.w    #3,d1                ; multiply by 8 to get ht of destMap when rot'd
  176.     mulu.w    d7,d1                ; multiply by rowbytes(destMap) = #words in
  177.     sub.w    d7,d1                ; destMap less one row
  178.     add.l    a3,d1                ; add the computed offset to the baseAddr of destMap
  179.     move.l    d1,lowerLeft-localVars(a0)    ; init lowerLeft
  180. ;
  181. ;-------------------------------------------------------------------------------
  182. ;    a0 = baseAddr for our locals        |    d0 = rowbytes of srcMap
  183. ;    a1 = points to bits of src bitMap    |    d1 = SCRATCH
  184. ;    a2 = SCRATCH                        |    d2 = colmCounter
  185. ;    a3 = dest bits                        |    d3 = current srcMap word 
  186. ;    a4 = SCRATCH                        |    d4 = colmBitLoop counter
  187. ;    a5 = not used                        |    d5 = current word destMap
  188. ;    a6 = not used                        |    d6 = insideLoop count (current bit)
  189. ;    a7 = not used                        |    d7 = rowBytes of dest bitMap
  190. ;-------------------------------------------------------------------------------
  191. ;
  192.  
  193. ;    _Debugger;
  194.     
  195. ; init wordCount to zero 
  196. ;
  197.     move.w    #0,wordCount-localVars(a0)    ; set wordCount to one before we start
  198. ;
  199. ; init colmLoop counter
  200. ;
  201.     move.w    d7,d2                ; get rowBytes(dest)
  202.     lsr        #1,d2                ; divide by 2 - d2 now contains the outer counter
  203.     move.w    d2,colmCount-localVars(a0)    ; put the max value away for reference
  204.     moveq.l    #0,d2                ; set d2 to zero since we use it for the counter
  205.  
  206. colmLoop
  207. ;
  208. ; this is the outside loop
  209. ;
  210.     move.w    #15,d4                ; init colmBitLoop counter to 15
  211.     move.l    lowerLeft-localVars(a0),currentWord-localVars(a0)    ; init currentWord    
  212.  
  213. colmBitLoop
  214. ;
  215. ; this is the loop that does the bit counting in the destMap - it is really a
  216. ; misuse of the 'dbra' instruction since it is not an independent loop but it
  217. ; is a quite cheap method of doing our counting
  218. ;
  219.  
  220. rowLoop
  221. ;
  222. ; loop across each row in the srcMap and keep count each time we do a row
  223. ; this 'rowCount' will used to compute the offset from 'lowerLeft'
  224. ;
  225.     move.w    (a1),d3                        ; get a word to rotate into d3
  226.     addq.w    #2,wordCount-localVars(a0)    ; add 1 for each word •••jdo•••
  227.     moveq.l    #0,d6                        ; clear d6    
  228.     move.w    #15,d6                        ; initialize the inside (bit) loop counter
  229.     
  230. innerLoop
  231. ;
  232. ; we will test each bit (15->0 ie. lt to rt) if it is set then we worry
  233. ; about going out and setting it in destMap otherwise we just increment the
  234. ; counters and test the next bit (cause we cleared them all at init)
  235. ;
  236.     btst    d6,d3                ; test bit pointed to in the current src word
  237.                                 ; by the inner (bit) loop counter
  238.     beq        NoBitToChange        ; if bits not set skip to next cause we cleared
  239.                                 ; them at init of bitMap else set the corresponding
  240.                                 ; bit before we bump the counter to the next bit
  241. ;
  242. ; bit needs to be set - get the word from memory, set bit and put it back
  243. ; this is very time consuming as each word is moved in/out of memory 16 times
  244. ; and a good place to look at for optimization - it probably means a complete
  245. ; rethink of the way we are doing this now
  246. ;
  247.     nop
  248.     movea.l    currentWord-localVars(a0),a2    ; get addr of currentWord
  249.     move.w    (a2),d5                            ; get currentWord
  250.     bset    d4,d5                            ; set proper bit in currentWord
  251.     move.w    d5,(a2)                            ; put the currentWord word back
  252.                                             ; into destMap (memory pt'd to by a3)    
  253.     nop
  254.     
  255. noBitToChange
  256. ;
  257. ; bit was cleared at init of bitMap so we come here to increment the
  258. ; counters - we need to move over 1 bit in the srcWord and up 1 row in
  259. ; our destMap (which is always subtracting rowBytes 
  260. ;
  261.     sub.l    d7,currentWord-localVars(a0)    ; subtract rowBytes(destMap) from current word
  262.     dbra    d6,innerLoop                    ; keep looping (thru bits) till d6 = -1
  263.     addq.l    #2,a1                            ; point to the next word in srcMap - this will take
  264.                                             ; us all the way thru the srcMap as simple as that !
  265.                                             ; Its the destMap that requires all the dang loops
  266.                                             ; to get the addr of the corresponding word in the
  267.                                             ; destMap
  268. doneWithSrcWord
  269. ;
  270. ; at this point we've just completed a word from the srcMap
  271. ;
  272.     cmp        wordCount-localVars(a0),d0        ; cmp wordCount to rowBytes-are we done with a row ?
  273.     bne        rowLoop                            ; no - do another word
  274.     
  275. doneWithRow
  276. ;
  277. ; we just completed a row so add 2 to the count
  278. ;
  279.     move.w    #0,wordCount-localVars(a0)        ; •••jdo••• reset wordCount to zero
  280.  
  281. ;    
  282. ; the following use of dbra keeps track of our destMap bit for us
  283. ;
  284.     move.l    lowerLeft-localVars(a0),currentWord-localVars(a0)    ; re-init currentWord    
  285.                                         ; set the currentWord to the lowerLeft(current)
  286.                                         ; lowerLeft is moved over (right) by a word each
  287.                                         ; time we do a row in the srcMap
  288.     dbra    d4,colmBitLoop                ; go thru the bits (15->0) in the
  289.                                         ; destMap - then exit and do it
  290.                                         ; again for rowBytes/2 times
  291.  
  292. doneWithDestWord
  293. ;
  294. ; were done counting thru the bits of a destMap word - at this point we have
  295. ; actually finished a column in the destMap. The column is a multiple of
  296. ; 16 bits wide (and being at least 1 colm) and as tall as the destMap is
  297. ; (which is also equal to rowBytes of the srcMap)
  298. ;
  299.     addq.l    #2,lowerLeft-localVars(a0)        ; this moves us into the next
  300.                                             ; 'column' of bits in the destMap
  301.     addq.w    #1,d2                            ; add 1 to the colmLoop counter
  302.     cmp        colmCount-localVars(a0),d2        ; are we done yet ?
  303.     bne        colmLoop                        ; no - do it again
  304.                                             ; else we're done
  305. ;
  306. ; were done so lets do our clean-up/restore and go away gracefully
  307. ;
  308. cleanUpTime                        ; clean-up and get outta dodge
  309.     movem.l    (sp)+,d3-d7/a2-a5    ; restore registers
  310.     unlk    a6                    ; clean up stack frame
  311.     move.l    (sp)+,a0            ; return address
  312.     add.l    #8,sp                ; pop parameters off stack
  313.     jmp        (a0)                 ; bye y'all!
  314.     
  315. ;
  316. ; set up our data storage area
  317. ;
  318. localVars                        ; the beginning of our local var storage area
  319. colmCount        ds.w    1
  320. currentWord        ds.l    1
  321. lowerLeft        ds.l    1
  322. wordCount        ds.w    1
  323.  
  324.     ENDP
  325.     
  326.     END
  327.     
  328.  
  329.